Table of Contents:

1. What are object variants ?
2. Shared fields
3. Circle-Ellipse problem

INTRO - GREETING

Nim for Beginners: Object Variants Part 1

INTRO - FOREWORDS

(What is the purpose of this video ?)

In this video i will teach you about object variants, what they are and how to use them, as well as compare them against objects with inheritance.

The code for this video and it's script/documentation styled with nimib, is in the links in the description as a form of offline tutorial.

What are object variants ?

Object variants are when making an object and using logic, to split it into several unique parts. This is done by using a case statement and enumerators. Object variants are an easy way of having as the name suggests variants of the same object.

Sometimes or often an object hierarchy would be an overkill, needless complication.

Let's start with a a simple example: First we make an enumerator withing a type section, with it's enumerations of line, circle, rectangle

type
  Kind = enum
    line, circle, rectangle

Secondly we make our object with it's variants by using a case statement, with the enumerator from above like this:

type
  Draw = object
    case kind: Kind
      of line:
        lx, ly: int
      of circle:
        cx, cy: int
        radius: float #PI = 3.14
      of rectangle:
        rx1, ry1, rx2, ry2: int

How this works is simple, you initialize a new variable of type Draw object, and then for it's field select one of it's kind enumerations, and then based on the kind of the object, you give that kind's field's data, and thus you have a variant of that object. Also note how we used different field names for each of the variants, that is because they cannot be the same, since they are declared in the same object.

Let's demonstrate this by making a variable for each of the object variants and echo them, also make a constant for pi, circle's radius:

const pi = 3.14
var drawLine = Draw(kind: line, lx: 10, ly: 50)
var drawCircle = Draw(kind: circle, cx: 10, cy: 50, radius: pi)
var drawRectangle = Draw(kind: rectangle, rx1: 10, ry1: 50, rx2: 10)

echo drawLine, " drawLine's type is: ", drawLine.type 
echo drawCircle, " drawCircle's type is: ", drawCircle.type 
echo drawRectangle, " drawRectangle's type is: ", drawRectangle.type

(kind: line, lx: 10, ly: 50) drawLine's type is: Draw
(kind: circle, cx: 10, cy: 50, radius: 3.14) drawCircle's type is: Draw
(kind: rectangle, rx1: 10, ry1: 50, rx2: 10, ry2: 0) drawRectangle's type is: Draw

Here we go 3 different variants of the same object Draw. We can also display their kind such as line, circle, rectangle that the case statement uses, so let's display that using "variableName.kind"

echo drawLine, " drawLine's type is: ", drawLine.type, " of kind: ", drawLine.kind
echo drawCircle, " drawCircle's type is: ", drawCircle.type, " of kind: ", drawCircle.kind 
echo drawRectangle, " drawRectangle's type is: ", drawRectangle.type, " of kind: ", drawRectangle.kind

(kind: line, lx: 10, ly: 50) drawLine's type is: Draw of kind: line
(kind: circle, cx: 10, cy: 50, radius: 3.14) drawCircle's type is: Draw of kind: circle
(kind: rectangle, rx1: 10, ry1: 50, rx2: 10, ry2: 0) drawRectangle's type is: Draw of kind: rectangle

Here we go it works.

Shared fields

When using Object Variants we can easily share fields between them all as well, this is as simple as adding those fields before or after the case statement. Let's try this with a different example:

type
  Enemies1 = enum
    footman, mage

  Armor = enum
    light, medium, heavy

  Spells = enum
    root, heal, arcaneMissiles

  Enemy = object
    damage: int
    attackRange: int
    health: int

    case kind: Enemies1
      of footman:
        armor: Armor
      of mage:
        spells: seq[Spells]

Okay here i have made 3 enumerators, 1x for the Enemies1 with footman and mage as it's enumerations, another for Armour our footman will be using and Spells for the mage.

In the object i have added 3 fields, that will be shared between both of the Object Variants, of damage, attackRange and health. And then i gave both of the variants their special field, of the enumerator i have made for each of them.

Now let's initialize a variable for each Object Variant kind and then display them both:

var soldier = Enemy(kind: footman, armor: medium, health: 200, damage: 5, attackRange: 100)
var sorcerer = Enemy(kind: mage, spells: @[root, heal], health: 75, damage: 10, attackRange: 600)

echo soldier, " soldier's type is: ", soldier.kind
echo sorcerer, " sorcerer's type is: ", sorcerer.kind

(damage: 5, attackRange: 100, health: 200, kind: footman, armor: medium) soldier's type is: footman
(damage: 10, attackRange: 600, health: 75, kind: mage, spells: @[root, heal]) sorcerer's type is: mage

Here we go, that's how you do Object Variants and have shared fields for them.

Circle-Ellipse problem

In case you have heard of the Circle-Ellipse problem or Rectangle-Square problem, object variants are the solution to this problem

Outro - Afterwords

Okay, that's it for this video, thanks for watching like, share and subscribe, aswell as click the bell icon if you liked it and want more, you can also follow me on twitter of the same name, and support me on Patreon. If you had any problems with any part of the video, let me know in the comment section, the code of this video, script and documentation, are in the link in the description, as a form of offline tutorial.

Thanks to my past and current Patrons

Past Patrons

• Goose_Egg: From April 4th 2021 to May 10th 2022
• Davide Galilei(1x month)

Current Patrons

• jaap groot (from October 2023)
• Dimitri Lesnoff (from October 2023)

Compiler Information

• Version used: E.G. 2.0.2
• Compiler settings used: none, ORC is now the default memory management option
• Timestamps:
  • 00:15 Start of video example

My and General Links

• Twitter
• Patreon
• Video's script/documentation styled with nimib as a form of offline tutorial:
• Visual Studio Code Shortcuts

Links to this video's subject

• Object Variants